#include "steernewmeter.h"

SteerNewMeter::SteerNewMeter(QWidget *parent)
    : QWidget(parent)
{
    m_precision=0;
    m_steps=10;
    m_thresholdFlag=false;

    m_foreground=QColor(Qt::yellow);
    m_background=QColor(39,39,39,150);

    m_thresholdEnabled=true;
    m_numericIndicatorEnabled=true;
    setMinValue(-45);//mmy
    setMaxValue(225);//mmy
    setValue(90);
    setStartAngle(225);//225 mmy
    setEndAngle(-45);//mmy
    setMinimumSize(QSize(80,80));
    setMaximumSize(QSize(80,80));
    setLabel(QStringLiteral("°"));//steer
    setUnits(QStringLiteral("°"));
    setThreshold(93);//mmy
    setEnableValidWindow(false);

    //mmy
    setBeginValidValue(15.0); //原来为40
    setEndValidValue(30.0);   //原来为50

    setEnableWarningWindow(false);
    //mmy
    setBeginWarningValue(0.0); //原来为30
    setEndWarningValue(45.0);   //原来为60
}

SteerNewMeter::~SteerNewMeter() {}
void SteerNewMeter::customTextList(const QStringList &list)
{
    _customTextList = list;
}
void SteerNewMeter::setValue(double value)
{
    if(value>m_maxValue)
    {
        m_value=m_maxValue;
        emit errorSignal(OutOfRange);
    }
    else
        if(value<m_minValue)
        {
            m_value=m_minValue;
            emit errorSignal(OutOfRange);
        }
        else
            m_value=value;

    if(m_thresholdEnabled)
        thresholdManager();
    update();
}

void SteerNewMeter::setValue(int value)
{
    setValue((double)value);
    update();
}

void SteerNewMeter::setMinValue(double value)
{
    m_minValue=value;
    update();
}

void SteerNewMeter::setMinValue(int value)
{
    setMinValue((double)value);
}


void SteerNewMeter::setMaxValue(double value)
{
    if(value > m_minValue)
    {
        m_maxValue=value;
        update();
    }
    else
        emit errorSignal(MaxValueError);
}

void SteerNewMeter::setMaxValue(int value)
{
    setMaxValue((double)value);
}


void SteerNewMeter::setThreshold(double value)
{
    if(value > m_minValue && value < m_maxValue)
    {
        m_threshold=value;
        update();
    }
    else
        emit errorSignal(ThresholdError);
}

void SteerNewMeter::setThreshold(int value)
{
    setThreshold((double)value);
}

void SteerNewMeter::setPrecision(int precision)
{
    m_precision=precision;
    update();
}

void SteerNewMeter::setPrecisionNumeric(int precision)
{
    m_precisionNumeric=precision;
    update();
}

void SteerNewMeter::setUnits(const QString &units)
{
    m_units = units;
    update();
}

void SteerNewMeter::setLabel(const QString &label)
{
    m_label = label;
}
void SteerNewMeter::setWindow(const QRect& rect)
{
    _windowRect = rect;
}
void SteerNewMeter::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);
    QPainter painter(this);
    painter.setRenderHint(QPainter::Antialiasing, true);
    int side = qMin(width(), height());
    painter.setViewport((width() - side) / 2, (height() - side) / 2,side, side);
    //    painter.setWindow(QRect(-side,-side,2*side,2*side));
    painter.setWindow(QRect(-38,-38,76,76));
    //    painter.setWindow(painter.viewport());

        // drawBackground(&painter);
        //drawCoverGlass(&painter);
         //drawTicks(&painter);
         //drawScale(&painter);
    drawUnits(&painter);//单位°
    drawThresholdLine(&painter);
    drawWarningWindow((&painter));
    drawValidWindow(&painter);
    drawNeedle(&painter);//指针
    drawNumericValue(&painter);//当前数值
        //drawLabel(&painter);
        //drawCrown(&painter);
}

void SteerNewMeter::setCustomTextList(const QStringList &customTextList)
{
    _customTextList = customTextList;
}

void SteerNewMeter::setSteps(int nSteps)
{
    m_steps=nSteps;
    update();
}

void SteerNewMeter::setStartAngle(double value)
{
    m_startAngle=value;
    update();
}

void SteerNewMeter::setEndAngle(double value)
{
    m_endAngle=value;
    update();
}

void SteerNewMeter::setForeground(const QColor &newForeColor)
{
    m_foreground = newForeColor;
    update();
}

void SteerNewMeter::setBackground(const QColor &newBackColor)
{
    m_background = newBackColor;
    update();
}


void SteerNewMeter::thresholdManager()
{
    if(m_value > m_threshold && !m_thresholdFlag)
    {
        m_thresholdFlag=true;
        emit thresholdAlarm(m_thresholdFlag);
    }
    else
        if(m_value < m_threshold && m_thresholdFlag)
        {
            m_thresholdFlag=false;
            emit thresholdAlarm(m_thresholdFlag);
        }
}

void SteerNewMeter::setThresholdEnabled(bool enable)
{
    m_thresholdEnabled=enable;
    update();
}

void SteerNewMeter::setNumericIndicatorEnabled(bool enable)
{
    m_numericIndicatorEnabled=enable;
    update();
}

void SteerNewMeter::setValueWithSpringEffect(int value)
{
    //    m_valAnimation.setStartValue(m_value);
    //    m_valAnimation.setEndValue((double)value);
    //    m_valAnimation.setEasingCurve(QEasingCurve::OutBack);
    //    m_valAnimation.start();
}

void SteerNewMeter::setBeginValidValue(double beginValue)
{
    m_beginValidValue=beginValue;
    update();
}

void SteerNewMeter::setEndValidValue(double endValue)
{
    m_endValidValue=endValue;
    update();
}

void SteerNewMeter::setEnableValidWindow(bool enable)
{
    m_enableValidWindow=enable;
    update();
}

void SteerNewMeter::setBeginWarningValue(double beginValue)
{
    m_beginWarningValue=beginValue;
    update();

}

void SteerNewMeter::setEndWarningValue(double endValue)
{
    m_endWarningValue=endValue;
    update();

}

void SteerNewMeter::setEnableWarningWindow(bool enable)
{
    m_enableWarningWindow=enable;
    update();
}

QString SteerNewMeter::valueText() const
{
    return _valueText;
}

void SteerNewMeter::setValueText(const QString &valueText)
{
    _valueText = valueText;
}
